<!DOCTYPE html>
<html class="client-nojs vector-feature-night-mode-disabled vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-1 vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-1 vector-sticky-header-enabled" lang="en" dir="ltr"><head>
<meta charset="UTF-8">
<title>Method overriding</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="canonical" href="https://en.wikipedia.org/wiki/Method_overriding"> <link href="./mw/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/skins.vector.styles.css" rel="stylesheet" type="text/css">
<link href="./mw/user.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" type="text/css" href="./mw/site.styles.css">
<link rel="stylesheet" type="text/css" href="./mw/noscript.css">
<link rel="stylesheet" type="text/css" href="./footer.css">
<link rel="stylesheet" type="text/css" href="./vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Method_overriding rootpage-Method_overriding skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading">
<span id="openzim-page-title" class="mw-page-title-main"><span class="mw-page-title-main">Method overriding</span></span>
</h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="en" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="en" dir="ltr">
<style data-mw-deduplicate="TemplateStyles:r1236090951">
/* start https://en.wikipedia.org/ */
.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}
/* end https://en.wikipedia.org/ */
</style><div role="note" class="hatnote navigation-not-searchable">Not to be confused with <a href="Function_overloading" title="Function overloading">Function overloading</a>.</div>
<p><b>Method overriding</b>, in <a href="Object-oriented_programming" title="Object-oriented programming">object-oriented programming</a>, is a language feature that allows a <a href="Subclass_(computer_science)" class="mw-redirect" title="Subclass (computer science)">subclass</a> or child class to provide a specific implementation of a <a href="Method_(computer_science)" class="mw-redirect" title="Method (computer science)">method</a> that is already provided by one of its <a href="Superclass_(computer_science)" class="mw-redirect" title="Superclass (computer science)">superclasses</a> or parent classes. In addition to providing data-driven algorithm-determined parameters across virtual network interfaces,<sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup> it also allows for a specific type of <a href="Polymorphism_(computer_science)" title="Polymorphism (computer science)">polymorphism</a> (<a href="Subtyping" title="Subtyping">subtyping</a>). The implementation in the subclass overrides (replaces) the implementation in the superclass by providing a method that has same name, same <a href="Parameter_(computer_science)" class="mw-redirect" title="Parameter (computer science)">parameters</a> or signature, and same return type as the method in the parent class.<sup id="cite_ref-flanagan_2-0" class="reference"><a href="#cite_note-flanagan-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup> The version of a method that is executed will be determined by the <a href="Object_(computer_science)" title="Object (computer science)">object</a> that is used to invoke it. If an object of a parent class is used to invoke the method, then the version in the parent class will be executed, but if an object of the subclass is used to invoke the method, then the version in the child class will be executed.<sup id="cite_ref-lewis-loftus_3-0" class="reference"><a href="#cite_note-lewis-loftus-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup> This helps in preventing problems associated with differential relay analytics which would otherwise rely on a framework in which method overriding might be obviated.<sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup><sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup> Some languages allow a <a href="Programmer" title="Programmer">programmer</a> to prevent a method from being overridden.
</p>
<meta property="mw:PageProp/toc">
<div class="mw-heading mw-heading2"><h2 id="Language-specific_examples">Language-specific examples</h2></div>
<div class="mw-heading mw-heading3"><h3 id="Ada">Ada</h3></div>
<p><a href="Ada_(programming_language)" title="Ada (programming language)">Ada</a> provides method overriding by default.
To favor early error detection (e.g. a misspelling),
it is possible to specify when a method
is expected to be actually overriding, or not. That will be checked by the compiler.
</p>
<div class="mw-highlight mw-highlight-lang-ada mw-content-ltr" dir="ltr"><pre> <span class="kd">type</span> <span class="kt">T</span> <span class="kr">is</span> <span class="kr">new</span> <span class="kt">Controlled</span> <span class="kr">with</span> <span class="p">......;</span>
<span class="kd">procedure</span> <span class="nf">Op</span><span class="p">(</span><span class="nv">Obj</span><span class="p">: </span><span class="nv">in</span> <span class="nv">out</span> <span class="nv">T</span><span class="p">;</span> <span class="nv">Data</span><span class="p">: </span><span class="nv">in</span> <span class="nv">Integer</span><span class="p">);</span>
<span class="kd">type</span> <span class="kt">NT</span> <span class="kr">is</span> <span class="kr">new</span> <span class="n">T</span> <span class="kr">with</span> <span class="kr">null record</span><span class="p">;</span>
<span class="kr">overriding</span> <span class="c1">-- overriding indicator</span>
<span class="kd">procedure</span> <span class="nf">Op</span><span class="p">(</span><span class="nv">Obj</span><span class="p">: </span><span class="nv">in</span> <span class="nv">out</span> <span class="nv">NT</span><span class="p">;</span> <span class="nv">Data</span><span class="p">: </span><span class="nv">in</span> <span class="nv">Integer</span><span class="p">);</span>
<span class="kr">overriding</span> <span class="c1">-- overriding indicator</span>
<span class="kd">procedure</span> <span class="nf">Op</span><span class="p">(</span><span class="nv">Obj</span><span class="p">: </span><span class="nv">in</span> <span class="nv">out</span> <span class="nv">NT</span><span class="p">;</span> <span class="nv">Data</span><span class="p">: </span><span class="nv">in</span> <span class="nv">String</span><span class="p">);</span>
<span class="c1">-- ^ compiler issues an error: subprogram "Op" is not overriding</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="C#">C#</h3></div>
<p><a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> does support method overriding, but only if explicitly requested using the modifiers <code class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><span class="k">override</span></code> and <code class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><span class="k">virtual</span></code> or <code class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><span class="k">abstract</span></code>.
</p><p><span class="mw-default-size" typeof="mw:File"></span>
</p>
<div class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><pre><span class="k">abstract</span><span class="w"> </span><span class="k">class</span><span class="w"> </span><span class="nc">Animal</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="kt">string</span><span class="w"> </span><span class="n">Name</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">get</span><span class="p">;</span><span class="w"> </span><span class="k">set</span><span class="p">;</span><span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="c1">// Methods</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="k">void</span><span class="w"> </span><span class="nf">Drink</span><span class="p">();</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="k">virtual</span><span class="w"> </span><span class="k">void</span><span class="w"> </span><span class="nf">Eat</span><span class="p">();</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="k">void</span><span class="w"> </span><span class="nf">Go</span><span class="p">();</span>
<span class="p">}</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Cat</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">Animal</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="kt">string</span><span class="w"> </span><span class="n">Name</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">get</span><span class="p">;</span><span class="w"> </span><span class="k">set</span><span class="p">;</span><span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="c1">// Methods</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="k">void</span><span class="w"> </span><span class="nf">Drink</span><span class="p">();</span><span class="w"> </span><span class="c1">// Warning: hides inherited drink(). Use new</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="k">override</span><span class="w"> </span><span class="k">void</span><span class="w"> </span><span class="nf">Eat</span><span class="p">();</span><span class="w"> </span><span class="c1">// Overrides inherited eat().</span>
<span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="k">void</span><span class="w"> </span><span class="nf">Go</span><span class="p">();</span><span class="w"> </span><span class="c1">// Hides inherited go().</span>
<span class="p">}</span>
</pre></div>
<p>When overriding one method with another, the <a href="Type_signature" title="Type signature">signatures</a> of the two methods must be identical (and with same visibility). In C#, <a href="Class_method" class="mw-redirect" title="Class method">class methods</a>, <a href="Indexer_(programming)" title="Indexer (programming)">indexers</a>, <a href="Property_(programming)" title="Property (programming)">properties</a> and events can all be overridden.
</p><p>Non-virtual or static methods cannot be overridden. The overridden base method must be <i>virtual</i>, <i>abstract</i>, or <i>override</i>.
</p><p>In addition to the modifiers that are used for method overriding, C# allows the <b>hiding</b> of an inherited property or method. This is done using the same signature of a property or method but adding the modifier <code class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><span class="k">new</span></code> in front of it.<sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>
</p><p>In the above example, hiding causes the following:
</p>
<div class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><pre><span class="n">Cat</span><span class="w"> </span><span class="n">cat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Cat</span><span class="p">();</span>
<span class="n">cat</span><span class="p">.</span><span class="n">Name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="err">…</span><span class="p">;</span><span class="w"> </span><span class="c1">// accesses Cat.Name</span>
<span class="n">cat</span><span class="p">.</span><span class="n">Eat</span><span class="p">();</span><span class="w"> </span><span class="c1">// calls Cat.Eat()</span>
<span class="n">cat</span><span class="p">.</span><span class="n">Go</span><span class="p">();</span><span class="w"> </span><span class="c1">// calls Cat.Go()</span>
<span class="p">((</span><span class="n">Animal</span><span class="p">)</span><span class="n">cat</span><span class="p">).</span><span class="n">Name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="err">…</span><span class="p">;</span><span class="w"> </span><span class="c1">// accesses Animal.Name!</span>
<span class="p">((</span><span class="n">Animal</span><span class="p">)</span><span class="n">cat</span><span class="p">).</span><span class="n">Eat</span><span class="p">();</span><span class="w"> </span><span class="c1">// calls Cat.Eat()!</span>
<span class="p">((</span><span class="n">Animal</span><span class="p">)</span><span class="n">cat</span><span class="p">).</span><span class="n">Go</span><span class="p">();</span><span class="w"> </span><span class="c1">// calls Animal.Go()!</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="C++">C++</h3></div>
<p><a href="C%2B%2B" title="C++">C++</a> does not have the keyword <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">super</span></code> that a subclass can use in Java to invoke the superclass version of a method that it wants to override. Instead, the name of the parent or base class is used followed by the <a href="Scope_resolution_operator" title="Scope resolution operator">scope resolution operator</a>. For example, the following code presents two <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">classes</a>, the base class <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Rectangle</span></code>, and the derived class <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Box</span></code>. <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Box</span></code> overrides the <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Rectangle</span></code> class's <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Print</span></code> method, so as also to print its height.<sup id="cite_ref-malik_7-0" class="reference"><a href="#cite_note-malik-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span class="cp">#include</span><span class="w"> </span><span class="cpf"><iostream></span>
<span class="c1">//---------------------------------------------------------------------------</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Rectangle</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="n">Rectangle</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">w</span><span class="p">)</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">length_</span><span class="p">(</span><span class="n">l</span><span class="p">),</span><span class="w"> </span><span class="n">width_</span><span class="p">(</span><span class="n">w</span><span class="p">)</span><span class="w"> </span><span class="p">{}</span>
<span class="w"> </span><span class="k">virtual</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">Print</span><span class="p">()</span><span class="w"> </span><span class="k">const</span><span class="p">;</span>
<span class="w"> </span><span class="k">private</span><span class="o">:</span>
<span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">length_</span><span class="p">;</span>
<span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">width_</span><span class="p">;</span>
<span class="p">};</span>
<span class="c1">//---------------------------------------------------------------------------</span>
<span class="kt">void</span><span class="w"> </span><span class="nf">Rectangle::Print</span><span class="p">()</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">// Print method of base class.</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="s">"Length = "</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="n">length_</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="s">"; Width = "</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="n">width_</span><span class="p">;</span>
<span class="p">}</span>
<span class="c1">//---------------------------------------------------------------------------</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Box</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="n">Rectangle</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="n">Box</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">w</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">h</span><span class="p">)</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">Rectangle</span><span class="p">(</span><span class="n">l</span><span class="p">,</span><span class="w"> </span><span class="n">w</span><span class="p">),</span><span class="w"> </span><span class="n">height_</span><span class="p">(</span><span class="n">h</span><span class="p">)</span><span class="w"> </span><span class="p">{}</span>
<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">Print</span><span class="p">()</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="k">override</span><span class="p">;</span>
<span class="w"> </span><span class="k">private</span><span class="o">:</span>
<span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">height_</span><span class="p">;</span>
<span class="p">};</span>
<span class="c1">//---------------------------------------------------------------------------</span>
<span class="c1">// Print method of derived class.</span>
<span class="kt">void</span><span class="w"> </span><span class="nf">Box::Print</span><span class="p">()</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="c1">// Invoke parent Print method.</span>
<span class="w"> </span><span class="n">Rectangle</span><span class="o">::</span><span class="n">Print</span><span class="p">();</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="s">"; Height = "</span><span class="w"> </span><span class="o"><<</span><span class="w"> </span><span class="n">height_</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>The method <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Print</span></code> in class <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Box</span></code>, by invoking the parent version of method <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Print</span></code>, is also able to output the private <a href="Variable_(programming)" class="mw-redirect" title="Variable (programming)">variables</a> <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">length</span></code> and <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">width</span></code> of the base class. Otherwise, these variables are inaccessible to <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Box</span></code>.
</p><p>The following <a href="Statement_(programming)" class="mw-redirect" title="Statement (programming)">statements</a> will <a href="Object_(computer_science)" title="Object (computer science)">instantiate</a> objects of type <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Rectangle</span></code> and <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Box</span></code>, and call their respective <code class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><span class="n">Print</span></code> methods:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">argc</span><span class="p">,</span><span class="w"> </span><span class="kt">char</span><span class="o">**</span><span class="w"> </span><span class="n">argv</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">Rectangle</span><span class="w"> </span><span class="n">rectangle</span><span class="p">(</span><span class="mf">5.0</span><span class="p">,</span><span class="w"> </span><span class="mf">3.0</span><span class="p">);</span>
<span class="w"> </span><span class="c1">// Outputs: Length = 5.0; Width = 3.0</span>
<span class="w"> </span><span class="n">rectangle</span><span class="p">.</span><span class="n">Print</span><span class="p">();</span>
<span class="w"> </span><span class="n">Box</span><span class="w"> </span><span class="n">box</span><span class="p">(</span><span class="mf">6.0</span><span class="p">,</span><span class="w"> </span><span class="mf">5.0</span><span class="p">,</span><span class="w"> </span><span class="mf">4.0</span><span class="p">);</span>
<span class="w"> </span><span class="c1">// The pointer to the most overridden method in the vtable in on Box::print,</span>
<span class="w"> </span><span class="c1">// but this call does not illustrate overriding.</span>
<span class="w"> </span><span class="n">box</span><span class="p">.</span><span class="n">Print</span><span class="p">();</span>
<span class="w"> </span><span class="c1">// This call illustrates overriding.</span>
<span class="w"> </span><span class="c1">// outputs: Length = 6.0; Width = 5.0; Height= 4.0</span>
<span class="w"> </span><span class="k">static_cast</span><span class="o"><</span><span class="n">Rectangle</span><span class="o">&></span><span class="p">(</span><span class="n">box</span><span class="p">).</span><span class="n">Print</span><span class="p">();</span>
<span class="p">}</span>
</pre></div>
<p>In <a href="C%2B%2B11" title="C++11">C++11</a>, similar to Java, a method that is declared <code>final</code> in the super class cannot be overridden; also, a method can be declared <code>override</code> to make the compiler check that it overrides a method in the base class.
</p>
<div class="mw-heading mw-heading3"><h3 id="Delphi">Delphi</h3></div>
<p>In <a href="Delphi_(programming_language)" class="mw-redirect" title="Delphi (programming language)">Delphi</a>, method overriding is done with the directive <b>override</b>, but only if a method was marked with the <b>dynamic</b> or <b>virtual</b> directives.
</p><p>The <b>inherited</b> reserved word must be called when you want to call super-class behavior
</p>
<div class="mw-highlight mw-highlight-lang-pascal mw-content-ltr" dir="ltr"><pre><span class="k">type</span>
<span class="w"> </span><span class="n">TRectangle</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">class</span>
<span class="w"> </span><span class="kp">private</span>
<span class="w"> </span><span class="n">FLength</span><span class="o">:</span><span class="w"> </span><span class="kt">Double</span><span class="o">;</span>
<span class="w"> </span><span class="n">FWidth</span><span class="o">:</span><span class="w"> </span><span class="kt">Double</span><span class="o">;</span>
<span class="w"> </span><span class="kp">public</span>
<span class="w"> </span><span class="k">property</span><span class="w"> </span><span class="py">Length</span><span class="w"> </span><span class="kp">read</span><span class="w"> </span><span class="nf">FLength</span><span class="w"> </span><span class="kp">write</span><span class="w"> </span><span class="nf">FLength</span><span class="o">;</span>
<span class="w"> </span><span class="k">property</span><span class="w"> </span><span class="py">Width</span><span class="w"> </span><span class="kp">read</span><span class="w"> </span><span class="nf">FWidth</span><span class="w"> </span><span class="kp">write</span><span class="w"> </span><span class="nf">FWidth</span><span class="o">;</span>
<span class="w"> </span><span class="k">procedure</span><span class="w"> </span><span class="nf">Print</span><span class="o">;</span><span class="w"> </span><span class="kp">virtual</span><span class="o">;</span>
<span class="w"> </span><span class="k">end</span><span class="o">;</span>
<span class="w"> </span><span class="n">TBox</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">class</span><span class="p">(</span><span class="n">TRectangle</span><span class="p">)</span>
<span class="w"> </span><span class="kp">public</span>
<span class="w"> </span><span class="k">procedure</span><span class="w"> </span><span class="nf">Print</span><span class="o">;</span><span class="w"> </span><span class="kp">override</span><span class="o">;</span>
<span class="w"> </span><span class="k">end</span><span class="o">;</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Eiffel">Eiffel</h3></div>
<p>In <a href="Eiffel_(programming_language)" title="Eiffel (programming language)">Eiffel</a>, <b>feature redefinition</b> is analogous to method overriding in C++ and Java. Redefinition is one of three forms of feature adaptation classified as <b>redeclaration</b>. Redeclaration also covers <b>effecting</b>, in which an implementation is provided for a feature which was deferred (abstract) in the parent class, and <b>undefinition</b>, in which a feature that was effective (concrete) in the parent becomes deferred again in the heir class. When a feature is redefined, the feature name is kept by the heir class, but properties of the feature such as its signature, contract (respecting restrictions for <a href="Precondition" title="Precondition">preconditions</a> and <a href="Postcondition" title="Postcondition">postconditions</a>), and/or implementation will be different in the heir. If the original feature in the parent class, called the heir feature's <b>precursor</b>, is effective, then the redefined feature in the heir will be effective. If the precursor is deferred, the feature in the heir will be deferred.<sup id="cite_ref-meyer_8-0" class="reference"><a href="#cite_note-meyer-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup>
</p><p>The intent to redefine a feature, as <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="n">message</span></code> in the example below, must be explicitly declared in the <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="kr">inherit</span></code> clause of the heir class.
</p>
<div class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><pre><span class="kr">class</span>
<span class="w"> </span><span class="nc">THOUGHT</span>
<span class="kr">feature</span>
<span class="w"> </span><span class="n">message</span>
<span class="w"> </span><span class="c1">-- Display thought message</span>
<span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="n">print</span><span class="w"> </span><span class="p">(</span><span class="s">"I feel like I am diagonally parked in a parallel universe.%N"</span><span class="p">)</span>
<span class="w"> </span><span class="kr">end</span>
<span class="kr">end</span>
<span class="kr">class</span>
<span class="w"> </span><span class="nc">ADVICE</span>
<span class="kr">inherit</span>
<span class="w"> </span><span class="nc">THOUGHT</span>
<span class="w"> </span><span class="kr">redefine</span>
<span class="w"> </span><span class="n">message</span>
<span class="w"> </span><span class="kr">end</span>
<span class="kr">feature</span>
<span class="w"> </span><span class="n">message</span>
<span class="w"> </span><span class="c1">-- Precursor</span>
<span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="n">print</span><span class="w"> </span><span class="p">(</span><span class="s">"Warning: Dates in calendar are closer than they appear.%N"</span><span class="p">)</span>
<span class="w"> </span><span class="kr">end</span>
<span class="kr">end</span>
</pre></div>
<p>In class <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="nc">ADVICE</span></code> the feature <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="n">message</span></code> is given an implementation that differs from that of its precursor in class <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="nc">THOUGHT</span></code>.
</p><p>Consider a class which uses instances for both <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="nc">THOUGHT</span></code> and <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="nc">ADVICE</span></code>:
</p>
<div class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><pre><span class="kr">class</span>
<span class="w"> </span><span class="nc">APPLICATION</span>
<span class="kr">create</span>
<span class="w"> </span><span class="n">make</span>
<span class="kr">feature</span><span class="w"> </span>
<span class="w"> </span><span class="n">make</span>
<span class="w"> </span><span class="c1">-- Run application.</span>
<span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="p">(</span><span class="kr">create</span><span class="w"> </span><span class="p">{</span><span class="nc">THOUGHT</span><span class="p">}).</span><span class="n">message</span><span class="p">;</span>
<span class="w"> </span><span class="p">(</span><span class="kr">create</span><span class="w"> </span><span class="p">{</span><span class="nc">ADVICE</span><span class="p">}).</span><span class="n">message</span>
<span class="w"> </span><span class="kr">end</span>
<span class="kr">end</span>
</pre></div>
<p>When instantiated, class <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="nc">APPLICATION</span></code> produces the following output:
</p>
<div class="mw-highlight mw-highlight-lang-output mw-content-ltr" dir="ltr"><pre><span class="go">I feel like I am diagonally parked in a parallel universe.</span>
<span class="go">Warning: Dates in calendar are closer than they appear.</span>
</pre></div>
<p>Within a redefined feature, access to the feature's precursor can be gained by using the language keyword <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="kc">Precursor</span></code>. Assume the implementation of <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="p">{</span><span class="nc">ADVICE</span><span class="p">}.</span><span class="n">message</span></code> is altered as follows:
</p>
<div class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><pre><span class="w"> </span><span class="n">message</span>
<span class="w"> </span><span class="c1">-- Precursor</span>
<span class="w"> </span><span class="kr">do</span>
<span class="w"> </span><span class="n">print</span><span class="w"> </span><span class="p">(</span><span class="s">"Warning: Dates in calendar are closer than they appear.%N"</span><span class="p">)</span>
<span class="w"> </span><span class="kc">Precursor</span>
<span class="w"> </span><span class="kr">end</span>
</pre></div>
<p>Invocation of the feature now includes the execution of <code class="mw-highlight mw-highlight-lang-eiffel mw-content-ltr" dir="ltr"><span class="p">{</span><span class="nc">THOUGHT</span><span class="p">}.</span><span class="n">message</span></code>, and produces the following output:
</p>
<div class="mw-highlight mw-highlight-lang-output mw-content-ltr" dir="ltr"><pre><span class="go">Warning: Dates in calendar are closer than they appear.</span>
<span class="go">I feel like I am diagonally parked in a parallel universe.</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Java">Java</h3></div>
<p>In <a href="Java_(programming_language)" title="Java (programming language)">Java</a>, when a subclass contains a method with the same signature (name and parameter types) as a method in its superclass, then the subclass's method overrides that of the superclass.
For example:
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="kd">class</span> <span class="nc">Thought</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">message</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">"I feel like I am diagonally parked in a parallel universe."</span><span class="p">);</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
<span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Advice</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">Thought</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="nd">@Override</span><span class="w"> </span><span class="c1">// @Override annotation in Java 5 is optional but helpful.</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">message</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">"Warning: Dates in calendar are closer than they appear."</span><span class="p">);</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
</pre></div>
<p>Class <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="n">Thought</span></code> represents the superclass and implements a method call <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="n">message</span><span class="p">()</span></code>. The subclass called <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="n">Advice</span></code> inherits every method that could be in the <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="n">Thought</span></code> class. Class <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="n">Advice</span></code> overrides the method <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="n">message</span><span class="p">()</span></code>, replacing its functionality from <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="n">Thought</span></code>.
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="n">Thought</span><span class="w"> </span><span class="n">parking</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Thought</span><span class="p">();</span>
<span class="n">parking</span><span class="p">.</span><span class="na">message</span><span class="p">();</span><span class="w"> </span><span class="c1">// Prints "I feel like I am diagonally parked in a parallel universe."</span>
<span class="n">Thought</span><span class="w"> </span><span class="n">dates</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Advice</span><span class="p">();</span><span class="w"> </span><span class="c1">// Polymorphism</span>
<span class="n">dates</span><span class="p">.</span><span class="na">message</span><span class="p">();</span><span class="w"> </span><span class="c1">// Prints "Warning: Dates in calendar are closer than they appear."</span>
</pre></div>
<p>When a subclass contains a method that overrides a method of the superclass, then that (superclass's) overridden method can be explicitly invoked from within a subclass's method by using the <a href="Keyword_(computer_programming)" class="mw-redirect" title="Keyword (computer programming)">keyword</a> <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="kd">super</span></code>.<sup id="cite_ref-lewis-loftus_3-1" class="reference"><a href="#cite_note-lewis-loftus-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup> (It cannot be explicitly invoked from any method belongings to a class that is unrelated to the superclass.)
The <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="kd">super</span></code> reference can be
</p>
<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Advice</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">Thought</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="nd">@Override</span>
<span class="w"> </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">message</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">"Warning: Dates in calendar are closer than they appear."</span><span class="p">);</span>
<span class="w"> </span><span class="kd">super</span><span class="p">.</span><span class="na">message</span><span class="p">();</span><span class="w"> </span><span class="c1">// Invoke parent's version of method.</span>
<span class="w"> </span><span class="p">}</span>
</pre></div>
<p>There are methods that a subclass cannot override. For example, in Java, a method that is declared final in the super class cannot be overridden. Methods that are declared private or static cannot be overridden either because they are implicitly final. It is also impossible for a class that is declared final to become a super class.<sup id="cite_ref-deitel_9-0" class="reference"><a href="#cite_note-deitel-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup>
</p>
<div class="mw-heading mw-heading3"><h3 id="Kotlin">Kotlin</h3></div>
<p>In <a href="Kotlin_(programming_language)" title="Kotlin (programming language)">Kotlin</a> we can simply override a function like this (note that the function must be <code class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><span class="n">open</span></code>):
</p>
<div class="mw-highlight mw-highlight-lang-kotlin mw-content-ltr" dir="ltr"><pre><span class="kd">fun</span><span class="w"> </span><span class="nf">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">val</span><span class="w"> </span><span class="nv">p</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Parent</span><span class="p">(</span><span class="m">5</span><span class="p">)</span>
<span class="w"> </span><span class="kd">val</span><span class="w"> </span><span class="nv">c</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Child</span><span class="p">(</span><span class="m">6</span><span class="p">)</span>
<span class="w"> </span><span class="n">p</span><span class="p">.</span><span class="na">myFun</span><span class="p">()</span>
<span class="w"> </span><span class="n">c</span><span class="p">.</span><span class="na">myFun</span><span class="p">()</span>
<span class="p">}</span>
<span class="kd">open</span><span class="w"> </span><span class="kd">class</span><span class="w"> </span><span class="nc">Parent</span><span class="p">(</span><span class="kd">val</span><span class="w"> </span><span class="nv">a</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">open</span><span class="w"> </span><span class="kd">fun</span><span class="w"> </span><span class="nf">myFun</span><span class="p">()</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">println</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="p">}</span>
<span class="kd">class</span><span class="w"> </span><span class="nc">Child</span><span class="p">(</span><span class="kd">val</span><span class="w"> </span><span class="nv">b</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="kt">Int</span><span class="p">)</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">Parent</span><span class="p">(</span><span class="n">b</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="kd">override</span><span class="w"> </span><span class="kd">fun</span><span class="w"> </span><span class="nf">myFun</span><span class="p">()</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">println</span><span class="p">(</span><span class="s">"overrided method"</span><span class="p">)</span>
<span class="p">}</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Python">Python</h3></div>
<p>In <a href="Python_(programming_language)" title="Python (programming language)">Python</a>, when a subclass contains a method that overrides a method of the superclass, you can also call the superclass method by calling <code class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><span class="nb">super</span><span class="p">(</span><span class="n">Subclass</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">method</span></code><sup id="cite_ref-python-3-super_10-0" class="reference"><a href="#cite_note-python-3-super-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup> instead of <code class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><span class="bp">self</span><span class="o">.</span><span class="n">method</span></code>.
Example:
</p>
<div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre><span class="k">class</span><span class="w"> </span><span class="nc">Thought</span><span class="p">:</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-></span> <span class="kc">None</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"I'm a new object of type Thought!"</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">message</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-></span> <span class="kc">None</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"I feel like I am diagonally parked in a parallel universe."</span><span class="p">)</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Advice</span><span class="p">(</span><span class="n">Thought</span><span class="p">):</span>
<span class="k">def</span><span class="w"> </span><span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-></span> <span class="kc">None</span><span class="p">:</span>
<span class="nb">super</span><span class="p">(</span><span class="n">Advice</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
<span class="k">def</span><span class="w"> </span><span class="nf">message</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-></span> <span class="kc">None</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s2">"Warning: Dates in calendar are closer than they appear"</span><span class="p">)</span>
<span class="nb">super</span><span class="p">(</span><span class="n">Advice</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">message</span><span class="p">()</span>
<span class="n">t</span> <span class="o">=</span> <span class="n">Thought</span><span class="p">()</span>
<span class="c1"># "I'm a new object of type Thought!"</span>
<span class="n">t</span><span class="o">.</span><span class="n">message</span><span class="p">()</span>
<span class="c1"># "I feel like I am diagonally parked in a parallel universe.</span>
<span class="n">a</span> <span class="o">=</span> <span class="n">Advice</span><span class="p">()</span>
<span class="c1"># "I'm a new object of type Thought!"</span>
<span class="n">a</span><span class="o">.</span><span class="n">message</span><span class="p">()</span>
<span class="c1"># "Warning: Dates in calendar are closer than they appear"</span>
<span class="c1"># "I feel like I am diagonally parked in a parallel universe.</span>
<span class="c1"># ------------------</span>
<span class="c1"># Introspection:</span>
<span class="nb">isinstance</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">Thought</span><span class="p">)</span>
<span class="c1"># True</span>
<span class="nb">isinstance</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">Advice</span><span class="p">)</span>
<span class="c1"># True</span>
<span class="nb">isinstance</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">Thought</span><span class="p">)</span>
<span class="c1"># True</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Ruby">Ruby</h3></div>
<p>In <a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a> when a subclass contains a method that overrides a method of the superclass, you can also call the superclass method by calling super in that overridden method. You can use alias if you would like to keep the overridden method available outside of the overriding method as shown with 'super_message' below.
</p><p>Example:
</p>
<div class="mw-highlight mw-highlight-lang-ruby mw-content-ltr" dir="ltr"><pre><span class="k">class</span><span class="w"> </span><span class="nc">Thought</span>
<span class="w"> </span><span class="k">def</span><span class="w"> </span><span class="nf">message</span>
<span class="w"> </span><span class="nb">puts</span><span class="w"> </span><span class="s2">"I feel like I am diagonally parked in a parallel universe."</span>
<span class="w"> </span><span class="k">end</span>
<span class="k">end</span>
<span class="k">class</span><span class="w"> </span><span class="nc">Advice</span><span class="w"> </span><span class="o"><</span><span class="w"> </span><span class="no">Thought</span>
<span class="w"> </span><span class="k">alias</span><span class="w"> </span><span class="ss">:super_message</span><span class="w"> </span><span class="ss">:message</span>
<span class="w"> </span><span class="k">def</span><span class="w"> </span><span class="nf">message</span>
<span class="w"> </span><span class="nb">puts</span><span class="w"> </span><span class="s2">"Warning: Dates in calendar are closer than they appear"</span>
<span class="w"> </span><span class="k">super</span>
<span class="w"> </span><span class="k">end</span>
<span class="k">end</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Notes">Notes</h2></div>
<style data-mw-deduplicate="TemplateStyles:r1239543626">
/* start https://en.wikipedia.org/ */
.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}
/* end https://en.wikipedia.org/ */
</style><div class="reflist reflist-columns references-column-width reflist-columns-2">
<ol class="references">
<li id="cite_note-1"><span class="mw-cite-backlink"><b><a href="#cite_ref-1">^</a></b></span> <span class="reference-text"><style data-mw-deduplicate="TemplateStyles:r1238218222">
/* start https://en.wikipedia.org/ */
.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}
/* end https://en.wikipedia.org/ */
</style><cite id="CITEREFZhang2015" class="citation book cs1">Zhang, Jie (2015). "A novel P2P overridden API for open data communications in WWW". <i>2015 IEEE International Conference on Consumer Electronics - Taiwan</i>. pp. <span class="nowrap">156–</span>157. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1109%2FICCE-TW.2015.7216830">10.1109/ICCE-TW.2015.7216830</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1-4799-8745-0</bdi>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:23295793">23295793</a>.</cite></span>
</li>
<li id="cite_note-flanagan-2"><span class="mw-cite-backlink"><b><a href="#cite_ref-flanagan_2-0">^</a></b></span> <span class="reference-text">Flanagan 2002, p. 107</span>
</li>
<li id="cite_note-lewis-loftus-3"><span class="mw-cite-backlink">^ <a href="#cite_ref-lewis-loftus_3-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-lewis-loftus_3-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text">Lewis & Loftus 2006, p.454</span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><b><a href="#cite_ref-4">^</a></b></span> <span class="reference-text"><cite id="CITEREFOverbey2011" class="citation book cs1">Overbey, J (2011). "Differential precondition checking: A lightweight, reusable analysis for refactoring tools". <i>2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011)</i>. pp. <span class="nowrap">303–</span>312. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1109%2FASE.2011.6100067">10.1109/ASE.2011.6100067</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1-4577-1639-3</bdi>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:5933208">5933208</a>.</cite></span>
</li>
<li id="cite_note-5"><span class="mw-cite-backlink"><b><a href="#cite_ref-5">^</a></b></span> <span class="reference-text"><cite id="CITEREFLi2014" class="citation journal cs1">Li, K (2014). "Residual investigation: Predictive and precise bug detection". <i>ACM Transactions on Software Engineering and Methodology</i>. <b>24</b> (2). <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1145%2F2656201">10.1145/2656201</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:47112802">47112802</a>.</cite></span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><b><a href="#cite_ref-6">^</a></b></span> <span class="reference-text"><cite id="CITEREFMössenböck2002" class="citation web cs1">Mössenböck, Hanspeter (2002-03-25). <a rel="nofollow" class="external text" href="http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/Part2.pdf">"Advanced C#: Overriding of Methods"</a> <span class="cs1-format">(PDF)</span>. Institut für Systemsoftware, Johannes Kepler Universität Linz, Fachbereich Informatik. pp. <span class="nowrap">6–</span>8<span class="reference-accessdate">. Retrieved <span class="nowrap">2011-08-02</span></span>.</cite></span>
</li>
<li id="cite_note-malik-7"><span class="mw-cite-backlink"><b><a href="#cite_ref-malik_7-0">^</a></b></span> <span class="reference-text">Malik 2006, p. 676</span>
</li>
<li id="cite_note-meyer-8"><span class="mw-cite-backlink"><b><a href="#cite_ref-meyer_8-0">^</a></b></span> <span class="reference-text">Meyer 2009, page 572-575</span>
</li>
<li id="cite_note-deitel-9"><span class="mw-cite-backlink"><b><a href="#cite_ref-deitel_9-0">^</a></b></span> <span class="reference-text">Deitel & Deitel 2001, p.474</span>
</li>
<li id="cite_note-python-3-super-10"><span class="mw-cite-backlink"><b><a href="#cite_ref-python-3-super_10-0">^</a></b></span> <span class="reference-text"><code class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">method</span></code> in Python 3 - see <a rel="nofollow" class="external free" href="https://docs.python.org/3/library/functions.html#super">https://docs.python.org/3/library/functions.html#super</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20181026035007/https://docs.python.org/3/library/functions.html#super">Archived</a> 2018-10-26 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></span>
</li>
</ol></div>
<div class="mw-heading mw-heading2"><h2 id="See_also">See also</h2></div>
<ul><li><a href="Implementation_inheritance" class="mw-redirect" title="Implementation inheritance">Implementation inheritance</a></li>
<li><a href="Inheritance_semantics" class="mw-redirect" title="Inheritance semantics">Inheritance semantics</a></li>
<li><a href="Method_overloading" class="mw-redirect" title="Method overloading">Method overloading</a></li>
<li><a href="Polymorphism_in_object-oriented_programming" class="mw-redirect" title="Polymorphism in object-oriented programming">Polymorphism in object-oriented programming</a></li>
<li><a href="Template_method_pattern" title="Template method pattern">Template method pattern</a></li>
<li><a href="Virtual_inheritance" title="Virtual inheritance">Virtual inheritance</a></li>
<li><a href="List_of_HTTP_header_fields#Common_non-standard_request_fields" title="List of HTTP header fields">X-HTTP-Method-Override HTTP Header</a></li></ul>
<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>
<ul><li>Deitel, H. M & Deitel, P. J.(2001). <i>Java How to Program</i> (4th ed.). Upper Saddle River, NJ: Prentice Hall.</li>
<li>Lewis, J. & Loftus, W. (2008). <i>Java: Software Solutions</i> (6th ed.). Boston, MA: Pearson Addison Wesley.</li>
<li>Malik, D. S.(2006). <i>C++ Programming: Program Design Including Data Structure.</i> (3rd ed.). Washington, DC: Course Technology.</li>
<li>Flanagan, David.(2002).<i>Java in a Nutshell.</i>Retrieved from <a rel="nofollow" class="external free" href="http://oreilly.com/catalog/9780596002831/preview#preview">http://oreilly.com/catalog/9780596002831/preview#preview</a></li>
<li><a href="Bertrand_Meyer" title="Bertrand Meyer">Meyer, Bertrand</a> (2009). <i>Touch of Class: Learning to Program Well with Objects and Contracts</i>. Springer.</li></ul>
<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>
<ul><li><a rel="nofollow" class="external text" href="http://www.codeproject.com/KB/architecture/OOP_Concepts_and_manymore.aspx#Overriding">Introduction to O.O.P. Concepts and More</a> by Nirosh L.w.C.</li>
<li><a rel="nofollow" class="external text" href="http://java.sun.com/docs/books/tutorial/java/IandI/override.html">Overriding and Hiding Methods</a> by <a href="Sun_Microsystems" title="Sun Microsystems">Sun Microsystems</a></li></ul></div><!--htdig_noindex--><div><div class="zim-footer">
This article is issued from <a class="external text" title="Last edited on 2024-07-05" href="https://en.wikipedia.org/wiki/?title=Method_overriding&oldid=1232705172">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
</body></html>